/** 【文件说明】：数组处理工具类
 *  【使用例子】：
 
    import { ArrayUtils } from '@/utils/arrayUtils';

    // 在某个方法或生命周期钩子中使用
    const numbers = [5, 3, 8, 1, 2, 9, 4, 7, 6];
    console.log(ArrayUtils.find(numbers, num => num > 5)); // 输出 8
    console.log(ArrayUtils.filter(numbers, num => num % 2 === 0)); // 输出 [8, 2, 4, 6]
    console.log(ArrayUtils.sort(numbers)); // 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9]
    console.log(ArrayUtils.sort(numbers, (a, b) => b - a)); // 输出 [9, 8, 7, 6, 5, 4, 3, 2, 1]

    const arr1 = [1, 2, 3];
    const arr2 = [4, 5, 6];
    console.log(ArrayUtils.mergeArrays(arr1, arr2)); // 输出 [1, 2, 3, 4, 5, 6]
    
 */
export class ArrayUtils {
    /**
     * 查找数组中的元素（返回第一个匹配项）
     * @param array 要查找的数组
     * @param predicate 用于测试每个元素的函数
     * @returns 返回第一个匹配的元素，如果没有找到则返回 undefined
     */
    static find<T>(array: T[], predicate: (element: T) => boolean): T | undefined {
      return array.find(predicate);
    }
  
    /**
     * 过滤数组中的元素
     * @param array 要过滤的数组
     * @param predicate 用于测试每个元素的函数
     * @returns 返回一个新的数组，包含所有通过测试的元素
     */
    static filter<T>(array: T[], predicate: (element: T) => boolean): T[] {
      return array.filter(predicate);
    }
  
    /**
     * 排序数组（升序）
     * @param array 要排序的数组
     * @param compareFn 可选的比较函数
     * @returns 返回一个新的已排序的数组
     */
    static sort<T>(array: T[], compareFn?: (a: T, b: T) => number): T[] {
      const sortedArray = [...array]; // 浅拷贝以避免修改原数组
      if (compareFn) {
        sortedArray.sort(compareFn);
      } else {
        sortedArray.sort();
      }
      return sortedArray;
    }
  
    /**
     * 合并多个数组
     * @param arrays 要合并的数组列表
     * @returns 返回一个新数组，包含所有输入数组的元素
     */
    static mergeArrays<T>(...arrays: T[][]): T[] {
      return arrays.reduce((acc, val) => acc.concat(val), []);
    }
  
    /**
     * 去重
     * @param array 要去重的数组
     * @returns 返回一个新的数组，其中不包含重复的元素
     */
    static unique<T>(array: T[]): T[] {
      return Array.from(new Set(array));
    }
  
    /**
     * 检查数组是否包含某个值
     * @param array 要检查的数组
     * @param value 要查找的值
     * @returns 如果数组包含该值则返回 true，否则返回 false
     */
    static includes<T>(array: T[], value: T): boolean {
      return array.includes(value);
    }
  
    /**
     * 获取数组的一部分
     * @param array 要切片的数组
     * @param start 切片开始的位置
     * @param end 可选的切片结束位置
     * @returns 返回一个新的数组，包含从 start 到 end 的元素
     */
    static slice<T>(array: T[], start: number, end?: number): T[] {
      return array.slice(start, end);
    }
  
    /**
     * 数组反转
     * @param array 要反转的数组
     * @returns 返回一个新的反转后的数组
     */
    static reverse<T>(array: T[]): T[] {
      return array.slice().reverse();
    }
  
    /**
     * 数组映射
     * @param array 要映射的数组
     * @param callback 映射函数
     * @returns 返回一个新的数组，包含应用映射函数后的结果
     */
    static map<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => U): U[] {
      return array.map(callback);
    }
  
    /**
     * 数组合并
     * @param array1 第一个数组
     * @param array2 第二个数组
     * @returns 返回一个新的数组，包含两个数组的所有元素
     */
    static concat<T>(array1: T[], array2: T[]): T[] {
      return array1.concat(array2);
    }
  }